// learningUtils.js - 学习页面工具函数

/**
 * 格式化学习时间
 * @param {number} minutes - 分钟数
 * @returns {string} 格式化后的时间字符串
 */
export function formatStudyTime(minutes) {
  if (minutes < 60) {
    return `${minutes}分钟`;
  } else {
    const hours = Math.floor(minutes / 60);
    const remainingMinutes = minutes % 60;
    return `${hours}小时${remainingMinutes > 0 ? remainingMinutes + '分钟' : ''}`;
  }
}

/**
 * 计算学习进度百分比
 * @param {number} current - 当前位置
 * @param {number} total - 总数
 * @returns {number} 进度百分比
 */
export function calculateProgressPercentage(current, total) {
  if (!total || total <= 0) return 0;
  return Math.round((current / total) * 100);
}

/**
 * 验证单词输入
 * @param {string} inputWord - 输入的单词
 * @param {string} correctWord - 正确的单词
 * @returns {Object} 验证结果
 */
export function validateWordInput(inputWord, correctWord) {
  // 基本验证：去除首尾空格并转换为小写
  const normalizedInput = inputWord.trim().toLowerCase();
  const normalizedCorrect = correctWord.trim().toLowerCase();
  
  const isCorrect = normalizedInput === normalizedCorrect;
  
  // 计算相似度（简单的编辑距离）
  const similarity = calculateSimilarity(normalizedInput, normalizedCorrect);
  
  return {
    isCorrect,
    similarity,
    message: isCorrect ? '拼写正确！' : getCorrectionMessage(similarity)
  };
}

/**
 * 计算字符串相似度（简单实现）
 * @param {string} str1 - 第一个字符串
 * @param {string} str2 - 第二个字符串
 * @returns {number} 相似度（0-1之间）
 */
function calculateSimilarity(str1, str2) {
  // 简单实现：计算相同字符的比例
  if (str1 === str2) return 1;
  if (str1.length === 0 || str2.length === 0) return 0;
  
  let matches = 0;
  const minLength = Math.min(str1.length, str2.length);
  const maxLength = Math.max(str1.length, str2.length);
  
  for (let i = 0; i < minLength; i++) {
    if (str1[i] === str2[i]) {
      matches++;
    }
  }
  
  return matches / maxLength;
}

/**
 * 获取纠正消息
 * @param {number} similarity - 相似度
 * @returns {string} 纠正消息
 */
function getCorrectionMessage(similarity) {
  if (similarity > 0.8) {
    return '拼写接近，再试一次！';
  } else if (similarity > 0.5) {
    return '拼写有误，但已有进步！';
  } else {
    return '拼写错误，请重新尝试！';
  }
}

/**
 * 生成随机测试问题
 * @param {Array} words - 单词数组
 * @param {number} count - 问题数量
 * @returns {Array} 测试问题数组
 */
export function generateTestQuestions(words, count = 10) {
  if (!words || words.length === 0) return [];
  
  // 随机选择单词
  const shuffledWords = [...words].sort(() => 0.5 - Math.random());
  const selectedWords = shuffledWords.slice(0, Math.min(count, words.length));
  
  // 为每个单词生成问题
  return selectedWords.map(word => ({
    id: word.id,
    word: word.word,
    questionType: 'meaning', // 可以扩展为多种题型
    options: generateOptions(word, words),
    correctAnswer: word.meaning
  }));
}

/**
 * 生成测试选项
 * @param {Object} targetWord - 目标单词
 * @param {Array} allWords - 所有单词
 * @returns {Array} 选项数组
 */
function generateOptions(targetWord, allWords) {
  // 选择一些干扰项
  const distractors = allWords
    .filter(word => word.id !== targetWord.id)
    .sort(() => 0.5 - Math.random())
    .slice(0, 3)
    .map(word => word.meaning);
  
  // 合并正确答案和干扰项，然后打乱顺序
  const options = [targetWord.meaning, ...distractors]
    .sort(() => 0.5 - Math.random());
  
  return options;
}

/**
 * 防抖函数
 * @param {Function} func - 要防抖的函数
 * @param {number} delay - 延迟时间（毫秒）
 * @returns {Function} 防抖后的函数
 */
export function debounce(func, delay) {
  let timeoutId;
  return function (...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => func.apply(this, args), delay);
  };
}

/**
 * 节流函数
 * @param {Function} func - 要节流的函数
 * @param {number} limit - 时间限制（毫秒）
 * @returns {Function} 节流后的函数
 */
export function throttle(func, limit) {
  let inThrottle;
  return function (...args) {
    if (!inThrottle) {
      func.apply(this, args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
}

/**
 * 显示加载提示
 * @param {string} title - 提示标题
 * @param {number} duration - 持续时间
 */
export function showLoading(title = '加载中...', duration = 2000) {
  wx.showLoading({
    title,
    mask: true
  });
  
  if (duration > 0) {
    setTimeout(() => {
      wx.hideLoading();
    }, duration);
  }
}

/**
 * 隐藏加载提示
 */
export function hideLoading() {
  wx.hideLoading();
}

/**
 * 显示成功提示
 * @param {string} title - 提示标题
 * @param {number} duration - 持续时间
 */
export function showSuccessToast(title = '操作成功', duration = 1500) {
  wx.showToast({
    title,
    icon: 'success',
    duration
  });
}

/**
 * 显示错误提示
 * @param {string} title - 提示标题
 * @param {number} duration - 持续时间
 */
export function showErrorToast(title = '操作失败', duration = 2000) {
  wx.showToast({
    title,
    icon: 'none',
    duration
  });
}

/**
 * 显示确认对话框
 * @param {Object} options - 对话框选项
 * @returns {Promise} 用户选择结果Promise
 */
export function showConfirmDialog(options) {
  const { title = '提示', content = '', confirmText = '确定', cancelText = '取消' } = options;
  
  return new Promise((resolve) => {
    wx.showModal({
      title,
      content,
      confirmText,
      cancelText,
      success(res) {
        if (res.confirm) {
          resolve(true);
        } else if (res.cancel) {
          resolve(false);
        }
      }
    });
  });
}

/**
 * 检查是否为空对象
 * @param {Object} obj - 要检查的对象
 * @returns {boolean} 是否为空对象
 */
export function isEmptyObject(obj) {
  return obj && Object.keys(obj).length === 0 && obj.constructor === Object;
}

/**
 * 深拷贝对象
 * @param {any} obj - 要拷贝的对象
 * @returns {any} 拷贝后的对象
 */
export function deepClone(obj) {
  if (obj === null || typeof obj !== 'object') return obj;
  
  if (obj instanceof Date) return new Date(obj.getTime());
  if (obj instanceof Array) return obj.map(item => deepClone(item));
  
  if (typeof obj === 'object') {
    const clonedObj = {};
    for (const key in obj) {
      if (obj.hasOwnProperty(key)) {
        clonedObj[key] = deepClone(obj[key]);
      }
    }
    return clonedObj;
  }
  
  return obj;
}